<!DOCTYPE html>
<html lang="zh-cn">

<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta http-equiv="X-UA-Compatible" content="ie=edge">
  <title>冰雹猜想的三进制模型</title>

  <style>
    body {
      padding: 0 2em;
    }

    a.ft,
    a.lk {
      text-decoration: none;
      color: inherit;
    }

    a.ft {
      background-color: #eef;
    }

    p.ft {
      font-weight: lighter;
    }

    /* useing mathjax font-family */
    p span {
      font-family: MJXZERO, MJXTEX-I, MJXTEX, MJXTEX-S1, MJXTEX-A;
      letter-spacing: 0.1em;
    }

    .track td {
      letter-spacing: 2px;
      /* font-family: 'Inconsolata'; */
      background-color: #f0f0f0;
      display: flex;
      flex-flow: column;
    }

    .track td tt {
      text-align: left;
    }

    .track td tt:nth-child(2n+1) {
      color: #e33;
    }

    .track td tt:nth-child(2) {
      color: #333;
    }

    .track td tt:nth-child(3) {
      color: #3ae;
    }

    div.center {
      display: flex;
      text-align: center;
      align-items: center;
      flex-direction: column;
    }

    table.example {
      text-align: right;
      margin: 2em auto 1em auto;
    }

    table.example caption {
      text-align: center;
      padding: 6px;
    }

    #exp1 {
      width: 12rem;
    }

    #exp1 th {
      background-color: #fea;
    }

    #exp1 tr:first-child th {
      background-color: #fff;
      text-align: center;
    }

    #exp1 tt {
      font-size: 1.5em;
    }

    #exp2,
    #exp3 {
      width: 18rem;
      text-align: center;
    }

    #exp2 b,
    #exp3 b {
      color: #fa3;
    }

    #exp2 tt,
    #exp3 tt {
      font-size: 1.5em;
    }

    #exp4 {
      width: 30em;
    }

    #exp4 td tt:nth-child(3) {
      color: #3ae;
    }

    #exp5 th {
      text-align: right;
      padding-right: 0.5em;
      width: 3em;
      font-weight: normal;
      font-size: 14px;
    }

    #tb1 {
      text-align: center;
      vertical-align: middle;
      width: 24em;
    }

    #tb1 thead {
      font-size: smaller;
    }

    #tb1 th {
      width: 6em;
    }

    #tb1 td {
      background-color: #f0f0f0;
    }
  </style>
  <script id="MathJax-script" async src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
  <!-- \(……\) 行内公式显示；$$ …… $$ 块状公式显示  -->
  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.15.10/styles/vs2015.min.css">
  <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.15.10/highlight.min.js"></script>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.15.10/languages/javascript.min.js"></script>
  <script>hljs.initHighlightingOnLoad();</script>

</head>

<body>
  <h1 style="font-family:'Arial Black', sans-serif; text-align: center;">冰雹猜想的三进制模型</h1>
  $$ \text{Jimgo , 2020 年 1 月} $$

  <!-- =================================第一章=================================================== -->
  <section>
    <h2>一、问题描述</h2>
    <p>冰雹猜想又称角谷猜想、Collatz猜想。原猜想定义为对任意的正整数\(n\),按照下方的规则进行操作:</p>
    $$
    f^0(n) =
    \begin{cases}
    n/2, & \text{ 如果} n \text{为偶数} \\
    3n+1, & \text{ 如果} n \text{为奇数}
    \end{cases}
    $$
    <p>若干次后，最终的结果会步入\([4,2,1,4,2,1,\ldots]\)的无限循环。</p>
    <p>为方便问题的研究，由于 \(n\) 为奇数时，\(3n+1\) 必为为偶数，本文对\(n\) 为奇数操作的结果直接除以\(2\) ，将原问题调整为</p>
    $$
    f(n) =
    \begin{cases}
    n/2, & \text{ 如果} n \text{为偶数} \\
    (3n+1)/2, & \text{ 如果} n \text{为奇数}
    \end{cases}
    $$
  </section>

  <!-- =================================第二章=================================================== -->
  <section>
    <h2>二、冰雹猜想的三进制表示</h2>
    <h3>1、数字的三进制表示</h3>
    <p>对于任一由十进制表示的正整数，均有其唯一的三进制表示，如\(15_{(10)} → 120_{(3)}\)。 </p>

    <table class="example" id="exp1">
      <caption>例一 15的操作步骤</caption>
      <tbody>
        <tr>
          <th>十进制</th>
          <th>三进制</th>
        </tr>
        <tr>
          <th><tt>15</tt></th>
          <td><tt>120</tt></td>
        </tr>
        <tr>
          <th><tt>23</tt></th>
          <td><tt>212</tt></td>
        </tr>
        <tr>
          <th><tt>35</tt></th>
          <td><tt>1022</tt></td>
        </tr>
        <tr>
          <th><tt>53</tt></th>
          <td><tt>1222</tt></td>
        </tr>
        <tr>
          <th><tt>80</tt></th>
          <td><tt>2222</tt></td>
        </tr>
        <tr>
          <th><tt>40</tt></th>
          <td><tt>1111</tt></td>
        </tr>
        <tr>
          <th><tt>20</tt></th>
          <td><tt>202</tt></td>
        </tr>
        <tr>
          <th><tt>10</tt></th>
          <td><tt>101</tt></td>
        </tr>
        <tr>
          <th><tt>5</tt></th>
          <td><tt>12</tt></td>
        </tr>
        <tr>
          <th><tt>8</tt></th>
          <td><tt>22</tt></td>
        </tr>
        <tr>
          <th><tt>4</tt></th>
          <td><tt>11</tt></td>
        </tr>
        <tr>
          <th><tt>2</tt></th>
          <td><tt>2</tt></td>
        </tr>
        <tr>
          <th><tt>1</tt></th>
          <td><tt>1</tt></td>
        </tr>
      </tbody>
    </table>

    <h3>2、数n为偶数时的操作表示</h3>
    <p>三进制表示中，一个数除以2，每一位变化先有以下三种情况：</p>
    $$ 0 → 0 ; 1 → 0 ;2 → 1 $$
    <p>其中位数为1时，除以2不足，需借位至下一位，计算进入借位状态，直到某一位为1时，计算才脱离借位状态。借位状态的计算变化如下：</p>
    $$ 0 → 1 ; 1 → 2 ;2 → 2 $$
    <table class="example" id="exp2">
      <caption>例二 不需借位除以2的逐步计算演示</caption>
      <tbody>
        <tr>
          <td>十进制</td>
          <td>三进制</td>
          <td>借位</td>
        </tr>
        <tr>
          <td><tt>20</tt></td>
          <td><tt>202</tt></td>
          <td><tt>0</tt></td>
        </tr>
        <tr>
          <td><tt></tt></td>
          <td><tt><b>1</b>02</tt></td>
          <td><tt>0</tt></td>
        </tr>
        <tr>
          <td><tt></tt></td>
          <td><tt>1<b>0</b>2</tt></td>
          <td><tt>0</tt></td>
        </tr>
        <tr>
          <td><tt>10</tt></td>
          <td><tt>10<b>1</b></tt></td>
          <td><tt>0</tt></td>
        </tr>
      </tbody>
    </table>

    <table class="example" id="exp3">
      <caption>例三 需要借位除以2的逐步计算演示</caption>
      <tbody>
        <tr>
          <td>十进制</td>
          <td>三进制</td>
          <td>借位</td>
        </tr>
        <tr>
          <td><tt>34</tt></td>
          <td><tt>1021</tt></td>
          <td><tt>0</tt></td>
        </tr>
        <tr>
          <td></td>
          <td><tt><b>0</b>021</tt></td>
          <td><tt>1</tt></td>
        </tr>
        <tr>
          <td></td>
          <td><tt>0<b>1</b>21</tt></td>
          <td><tt>1</tt></td>
        </tr>
        <tr>
          <td></td>
          <td><tt>01<b>2</b>1</tt></td>
          <td><tt>1</tt></td>
        </tr>
        <tr>
          <td><tt>17</tt></td>
          <td><tt>012<b>2</b></tt></td>
          <td><tt>0</tt></td>
        </tr>
      </tbody>
    </table>

    <h3>3、数n为奇数时的操作表示</h3>
    <p>计算第一步是 \( 3 × n \) 。由于是三进制，只需将该数左移一位后补零即可</p>
    <p>如十进制的 \( 5 × 3 = 15\) ,三进制表示为 \( 12 ≪ 1 = 120\)。</p>
    <p>计算第二步是 \( (3n+1)/2 \) 。因为\(n\)为奇数，\(3n\)亦为奇数，所以直接进行除以 2 操作末位必然是借位的状态。此时末尾补上的 1 ，按照上文偶数规则会直接化为 2 。
    </p>
    <p>综上所述，\((3n+1)/2 \) 操作在三进制中，只需先将该数按除以2的规则处理各个位数，最后在末尾补上2即可。</p>
    <p>如十进制的 \( (3×15+1)/2 = 23 \)，三进制表示该过程为 \( 120 → 21 → 212\)。</p>

    <h3>4、操作表示小结</h3>
    <p>冰雹猜想在三进制表示中，每一位的变化可以如下表述：</p>
    $$
    \begin{cases}
    0 → 0, & \text{ 不借位} \\
    1 → 0, & \text{ 不借位} \\
    2 → 1, & \text{ 不借位} \\
    0 → 1, & \text{ 要借位} \\
    1 → 2, & \text{ 要借位} \\
    2 → 2, & \text{ 要借位} \\
    0 → 2, & \text{ 要借位，而且是末尾后的一位} \\
    \end{cases}
    $$
  </section>

  <!-- =================================第三章=================================================== -->
  <section>
    <h2>三、模型的抽象化</h2>
    <p>只考虑三进制中每一位的变化规则，是不足以建立合适的数学模型，借位的状态、数\(n\)的三进制位数长度都要编入计算变量，在每一步计算操作中进行考量。</p>
    <p>事实上冰雹猜想可以有一个更形象化描述。想象有这么一个车间，在一条足够长的履带上放满了0、1、2三类零件，履带上方有一个叫做“借位”的机器人，会遵循冰雹猜想的规则，从左往右逐个对零件进行加工，自己也按规则改变借位的状态。</p>

    <p>为了更形象化，下文中会以</p>
    <tt>▁</tt> 表示零件 ０；<br>
    <tt>▄</tt> 表示零件 １；<br>
    <tt>█</tt> 表示零件 ２；<br>
    <tt style="color: #e33;">□</tt> 表示机器人在空载（０）状态；<br>
    <tt style="color: #e33;">■</tt> 表示机器人在满载（１）状态；<br>
    <tt style="color: #e33;">☆</tt> 表示机器人在空载（０）<a class="ft" href="#f1">完结<sup>①</sup></a>；<br>
    <tt style="color: #e33;">★</tt> 表示机器人在满载（１）<a class="ft" href="#f1">完结<sup>②</sup></a>；<br>

    <table class="example" id="exp4">
      <caption>
        例四 ( 3 × 22459 + 1 ) / 2 = 33689 的机械操作表示
        <br>
        \(1010210211_{(3)} → 1201012202_{(3)}\)
      </caption>
      <tbody class="track">
        <tr>
          <td><tt>&nbsp;</tt><tt>▄▁▄▁█▄▁█▄▄</tt><tt>１０１０２１０２１１</tt></td>
        </tr>
        <tr>
          <td><tt>■</tt><tt>▁▁▄▁█▄▁█▄▄</tt><tt>００１０２１０２１１</tt></td>
        </tr>
        <tr>
          <td><tt style="text-indent: calc(1em +  2px) ;">■</tt><tt>▁▄▄▁█▄▁█▄▄</tt><tt>０１１０２１０２１１</tt></td>
        </tr>
        <tr>
          <td><tt style="text-indent: calc(2em +  4px) ;">□</tt><tt>▁▄█▁█▄▁█▄▄</tt><tt>０１２０２１０２１１</tt></td>
        </tr>
        <tr>
          <td><tt style="text-indent: calc(3em +  6px) ;">□</tt><tt>▁▄█▁█▄▁█▄▄</tt><tt>０１２０２１０２１１</tt></td>
        </tr>
        <tr>
          <td><tt style="text-indent: calc(4em +  8px) ;">□</tt><tt>▁▄█▁▄▄▁█▄▄</tt><tt>０１２０１１０２１１</tt></td>
        </tr>
        <tr>
          <td><tt style="text-indent: calc(5em + 10px) ;">■</tt><tt>▁▄█▁▄▁▁█▄▄</tt><tt>０１２０１００２１１</tt></td>
        </tr>
        <tr>
          <td><tt style="text-indent: calc(6em + 12px) ;">■</tt><tt>▁▄█▁▄▁▄█▄▄</tt><tt>０１２０１０１２１１</tt></td>
        </tr>
        <tr>
          <td><tt style="text-indent: calc(7em + 14px) ;">■</tt><tt>▁▄█▁▄▁▄█▄▄</tt><tt>０１２０１０１２１１</tt></td>
        </tr>
        <tr>
          <td><tt style="text-indent: calc(8em + 16px) ;">□</tt><tt>▁▄█▁▄▁▄██▄</tt><tt>０１２０１０１２２１</tt></td>
        </tr>
        <tr>
          <td><tt style="text-indent: calc(9em + 18px) ;">■</tt><tt>▁▄█▁▄▁▄██▁</tt><tt>０１２０１０１２２０</tt></td>
        </tr>
        <tr>
          <td><tt style="text-indent: calc(10em + 20px) ;">★</tt><tt>▁▄█▁▄▁▄██▁█</tt><tt>０１２０１０１２２０２</tt></td>
        </tr>
      </tbody>
    </table>

    <p id="rb_rules">想象一下这些零件是0，1，2个箱子，那么容易总结出“借位”机器人的工作准则：</p>
    <p>1.处在空载状态，就搬走零件上的一个箱子，除非没有得搬；</p>
    <p>2.处在满载状态，就给零件上加盖一个箱子，除非已加满了；</p>
    <p>3.如果零件只有一个箱子，改变装载状态；</p>
    <p>4.如果前面再没有零件，而且处在满载状态，那就放下两个箱子，满载完结；</p>
    <p>5.如果前面再没有零件，而且处在空载状态，空载完结。</p>

    <p>下面是核心算法的javascript代码。</p>
    <pre>
      <code class="javascript">
/* javascript 代码 */
let track = [];// 履带
let robot = 0; // 机器人

// 一次操作，可以看做是机器人行走一趟履带
function trip() {
  robot = 0;

  // 履带上每一个零件（数位）的变化
  for (let i = 0; i < track.length; i++) {
    if (robot === 1) {
      // 机器人满载状态时（进入借位）的规则
      switch (track[i]) {
        case 0:
          track[i] = 1;
          break;
        case 1:
          track[i] = 2;
          // 设置机器人为空载（退出借位）状态
          robot = 0;
          break;
        case 2:
          break;
      }
    } else {
      // 机器人空载状态时（退出借位）的规则
      switch (track[i]) {
        case 0:
          break;
        case 1:
          track[i] = 0;
          // 设置机器人为满载（进入借位）状态
          robot = 1;
          break;
        case 2:
          track[i] = 1;
          break;
      }
    }
  }

  // 零件队列末尾的处理。如果机器人满载，那么就在末尾添加 2
  if (robot === 1) track.push(2);
}
      </code>
    </pre>

    <p>可以看出，机器人加工完一个零件后，该零件可立即交给下一个机器人进行加工。履带上部署多个机器人组成的流水线，会更方便数学模型的建立。</p>

    <table class="example" id="exp5">
      <caption style="width: 16em;">例五 数21的流水线操作</caption>
      <tbody class="track">
        <tr>
          <th>&nbsp;</th>
          <td style="background-color: #fff;"><tt style="color: #333;">０１２３４</tt></td>
        </tr>
        <tr>
          <th>0</th>
          <td><tt>&nbsp;</tt><tt>█▄▁</tt></td>
        </tr>
        <tr>
          <th>1</th>
          <td><tt>□</tt><tt>▄▄▁</tt></td>
        </tr>
        <tr>
          <th>2</th>
          <td><tt>■■</tt><tt>▁▁▁</tt></td>
        </tr>
        <tr>
          <th>3</th>
          <td><tt>□■■</tt><tt>▁▄▄</tt></td>
        </tr>
        <tr>
          <th>4</th>
          <td><tt>□■□★</tt><tt>▁▁██</tt></td>
        </tr>
        <tr>
          <th>5</th>
          <td><tt>□□■□</tt><tt>▁▁█▄</tt></td>
        </tr>
        <tr>
          <th>6</th>
          <td><tt>□□□□☆</tt><tt>▁▁▄█</tt></td>
        </tr>
        <tr>
          <th>7</th>
          <td><tt>□□■□☆</tt><tt>▁▁▁▄</tt></td>
        </tr>
        <tr>
          <th>8</th>
          <td><tt>□□□□☆</tt><tt>▁▁▁█</tt></td>
        </tr>
      </tbody>
    </table>
  </section>

  <!-- =================================第四章=================================================== -->
  <section>
    <h2>四、问题的等价模型</h2>
    <p>基于<a class="ft" href="#exp5">第三章</a>的流水线模型，我们约定：</p>
    <p>以\([0,1,2,…,i]\)标注履带上的位置，在<a class="ft" href="#exp5">例五</a>中，第 \(i\) 步即为第 \(i\) 列；</p>
    <p>以\([0,1,2,…,j]\)标注流水线由左往右前进的步数，在<a class="ft" href="#exp5">例五</a>中，第 \(j\) 步即为第 \(j\) 行；</p>

    <p>\(R^i_j\) 表示第 \(j\) 行第 \(i\) 列的机器人状态；在<a class="ft" href="#exp5">例五</a>中，\(R^0_3\) 为
      <tt style="color: #e33;">□</tt></p>
    <p>\(B^i_j\) 表示第 \(j\) 行第 \(i\) 列的零件类型；在<a class="ft" href="#exp5">例五</a>中，\(B^1_2\) 为 <tt>▁</tt></p>
    <p>\(L_j\) 表示第 \(j\) 行当前零件队列的末尾的下一位置；在<a class="ft" href="#exp5">例五</a>中，\(L_3\) 为 4,\(L_4\) 为 5</p>

    <p>同时基于前文的分析，可推导出以下的数学关系：</p>
    <h3>1、末尾位置 \(L_j\)</h3>
    <p>在流水线模型中，只有末尾的机器人处于满载状态时，零件队列才能向右方前进一位。由此可得 \(L_j\) 的计算关系：</p>
    $$
    L_j =
    \begin{cases}
    L_{j-1}+1,& \text{如果 } R^{L_{j-1} - 1}_{j-1} = 1 \\
    L_{j-1},& \text{如果 } R^{L_{j-1} - 1}_{j-1} \ne 1
    \end{cases}
    $$
    <p>仍用<a class="ft" href="#exp5">例五</a>说明。边界条件\(L_0 = 4\)，由于当\(i > j\)时，\(R^3_0, R^3_1, R^3_2\) 均不等于 1，\(L_1, L_2,
      L_3\) 均为等于4。\(R^3_3\) 等于
      1，所以\(L_4
      = L_3 + 1 = 5\)。</p>

    <p>为方便模型的建立，约定：</p>
    $$
    \begin{aligned}
    R^i_j = 0, \text{ 如果 } i \ge L_j ; \\
    B^i_j = 0, \text{ 如果 } i \gt L_j ;
    \end{aligned}
    $$

    <h3>2、借位状态 \(R^i_j\)</h3>
    <p>“借位”机器人是个记忆机器，自身状态仅与上一步有关。按照<a class="ft" href="#rb_rules">第三章</a>的分析，令 \(G(r, b)\)
      为借位状态的变化函数，在javascript中可以将计算步骤简写为：</p>

    <pre>
      <code class="javascript">
/**
 * 函数 G 借位计算函数
 * 参数 r 借位状态 [0,1]
 * 参数 b 位的数值 [0,1,2]
 * 返回 计算后的借位状态
 */
const G = (r, b) => r ^ b & 1;
      </code>
    </pre>

    <p>得到\(R^i_j\)的计算关系</p>
    $$
    R^i_j = G(R^{i-1}_{j-1}, B^{i-1}_{j-1})
    $$

    <h3>3、位数\(B^i_j\)</h3>
    <p>位数的计算要考虑当前位是否末尾位。计算规则如下表：</p>

    <table class="example" id="tb1">
      <caption>表一 三进制位 \(B^i_j\) 计算规则表</caption>
      <thead>
        <tr>
          <th>末尾判断 <br> \(L_j = i \text{ ?} \)</th>
          <th>借位 <br> \(R^{i-1}_{j-1}\)</th>
          <th>数位 <br> \(B^i_{j-1}\)</th>
          <th>结果 <br> \(B^i_j\)</th>
        </tr>
      </thead>
      <tbody>
        <tr>
          <td>0</td>
          <td>0</td>
          <td>0</td>
          <td>0</td>
        </tr>
        <tr>
          <td>0</td>
          <td>0</td>
          <td>1</td>
          <td>0</td>
        </tr>
        <tr>
          <td>0</td>
          <td>0</td>
          <td>2</td>
          <td>1</td>
        </tr>
        <tr>
          <td>0</td>
          <td>1</td>
          <td>0</td>
          <td>1</td>
        </tr>
        <tr>
          <td>0</td>
          <td>1</td>
          <td>1</td>
          <td>2</td>
        </tr>
        <tr>
          <td>0</td>
          <td>1</td>
          <td>2</td>
          <td>2</td>
        </tr>
        <tr>
          <td>1</td>
          <td>0</td>
          <td>0</td>
          <td>0</td>
        </tr>
        <tr>
          <td>1</td>
          <td>1</td>
          <td>0</td>
          <td>2</td>
        </tr>
      </tbody>
    </table>

    <p>根据上表，可以得到如下的javascript代码：</p>
    <pre>
      <code class="javascript">
/**
* 函数 h0 非末尾位的计算函数
* 参数 r  借位状态 [0,1]
* 参数 b  位的数值 [0,1,2]
* 返回 计算后位的数值
*/
const h0 = (r, b) => r ? 2 >> !b : b >> 1 ;

/**
* 函数 h0 末尾位的计算函数
* 参数 r  借位状态 [0,1]
* 返回 计算后位的数值
*/
const h1 = (r) => r << 1;

/**
* 函数 H 位的计算函数，合并了函数 h0(r,b) 及 h1(r)
* 参数 r 借位状态 [0,1]
* 参数 b 位的数值 [0,1,2]
* 参数 l 是否末尾 [0,1]
* 返回 计算后位的数值
*/
const H = (r, b, l) => l ? h1(r) : h0(r, b);
      </code>
    </pre>

    <p>由上面的函数\(H(r, b, l)\)，可以得到\(B^i_j\)的计算关系：</p>
    $$
    B^i_j = H(R^{i-1}_{j-1}, B^{i-1}_{j-1}, L_j)
    $$

  </section>

  <!-- =================================第五章=================================================== -->
  <section>
    <h2>五、猜想的等价问题</h2>
    <p>目光最终回到冰雹猜想。原猜想为对于任意正整数 \(n\) 经过有限次按奇偶数规则计算操作后，必定进入<a class="ft" href="#f2"> \([2,1]\) 循环<sup>③</sup>
      </a>。要从反面证明该问题，需要证明两个方面：</p>
    <h3>1、冰雹猜想不存在另一种循环；</h3>

    <table class="example" id="exp7">
      <caption style="width: 16em;">例六 数8的流水线操作<br>及[1，2]终结循环</caption>
      <tbody class="track">
        <tr>
          <th>&nbsp;</th>
          <td style="background-color: #fff;"><tt style="color: #333;">０１２３４５</tt></td>
        </tr>
        <tr>
          <th>0</th>
          <td><tt>&nbsp;</tt><tt>██</tt></td>
        </tr>
        <tr>
          <th>1</th>
          <td><tt>□</tt><tt>▄█</tt></td>
        </tr>
        <tr>
          <th>2</th>
          <td><tt>■□</tt><tt>▁▄</tt></td>
        </tr>
        <tr>
          <th>3</th>
          <td><tt>□□</tt><tt>▁█</tt></td>
        </tr>
        <tr>
          <th>4</th>
          <td><tt>□□</tt><tt>▁▄</tt></td>
        </tr>
        <tr>
          <th>5</th>
          <td><tt>□■</tt><tt>▁▁</tt></td>
        </tr>
        <tr>
          <th>6</th>
          <td><tt>□□★</tt><tt>▁▁█</tt></td>
        </tr>
        <tr>
          <th>7</th>
          <td><tt>□□□</tt><tt>▁▁▄</tt></td>
        </tr>
        <tr>
          <th>8</th>
          <td><tt>□□■</tt><tt>▁▁▁</tt></td>
        </tr>
        <tr>
          <th>9</th>
          <td><tt>□□□★</tt><tt>▁▁▁█</tt></td>
        </tr>
      </tbody>
    </table>

    <!-- <p>本文的模型，或许对第一类问题的证明有帮助。</p> -->
    <p>假设存在这么一组循环，循环的其中一个流水线的机器人、零件、队列长度分别为</p>
    $$
    [R^0_0,R^1_0,\ldots,R^l_0], \quad
    [B^0_0,B^1_0,\ldots,B^l_0], \quad
    L_0 = l
    $$
    <p>设循环的步数是 \(T\) , 零件队列前进的位移是 \(M\)，那么该初始状态输入应满足如下方程组：</p>
    $$
    \begin{cases}
    R^M_T = R^0_0 ,\\
    R^{M+1}_T = R^1_0 ,\\
    R^{M+2}_T = R^2_0 ,\\
    \vdots \\
    R^{M+l}_T = R^l_0 ,\\
    \\
    B^M_T = B^0_0 ,\\
    B^{M+1}_T = B^1_0 ,\\
    B^{M+2}_T = B^2_0 ,\\
    \vdots \\
    B^{M+l}_T = B^l_0 ,\\
    \\
    L_T = L_0 + M = l + M
    \end{cases}
    $$
    <p>如果能证明上述方程组当且仅当 \(T = 3, M = 1 \) 时可解，那么猜想的第一类问题就得以证明不存在。</p>

    <h3>2、冰雹猜想不存在发散不收敛的情况。</h3>
    <p>值得留意的是，操作过程中，队列前面的数值为0的空载位是没必要列入计算的。如果去除前面多余的零，流水线模型有助于第二类问题的证明。</p>

    <table class="example" id="exp8">
      <caption style="width: 16em;">例八 数21的流水线操作（去零）</caption>
      <tbody class="track">
        <tr>
          <th>&nbsp;</th>
          <td style="background-color: #fff;"><tt style="color: #333;">０１２３</tt></td>
        </tr>
        <tr>
          <th>0</th>
          <td><tt>&nbsp;</tt><tt>█▄▁</tt></td>
        </tr>
        <tr>
          <th>1</th>
          <td><tt>□</tt><tt>▄▄▁</tt></td>
        </tr>
        <tr>
          <th>2</th>
          <td><tt>■■</tt><tt>▁▁▁</tt></td>
        </tr>
        <tr>
          <th>3</th>
          <td><tt>■■</tt><tt>▄▄</tt></td>
        </tr>
        <tr>
          <th>4</th>
          <td><tt>■□★</tt><tt>▁██</tt></td>
        </tr>
        <tr>
          <th>5</th>
          <td><tt>■□</tt><tt>█▄</tt></td>
        </tr>
        <tr>
          <th>6</th>
          <td><tt>□□☆</tt><tt>▄█</tt></td>
        </tr>
        <tr>
          <th>7</th>
          <td><tt>■□☆</tt><tt>▁▄</tt></td>
        </tr>
        <tr>
          <th>8</th>
          <td><tt>□☆</tt><tt>█</tt></td>
        </tr>
      </tbody>
    </table>

    <p>根据<a class="ft" href="#tb1">第四章</a>的计算规则，容易推导出在一步操作之内，队列首端借位、数位同时清零的位数最多只有一位；队列末端位数最多也只增加一位。</p>
    <p>令 \(A_j\) 表示队列首位的位置，并规定初始条件 \(A_j = -1\) ，有</p>

    $$
    A_j =
    \begin{cases}
    A_{j-1}+1,& \text{如果 } R^{A_{j-1} + 1}_{j-1} = 0 \text{ 而且 } B^{A_{j-1} + 1}_{j-1} = 0 \\
    A_{j-1},& \text{其他 }
    \end{cases}
    $$

    <p>令 \(L^\prime_j\) 表示队列长度，易得 \(L^\prime_j = L_j - A_j \) ，那么对于任意正整数 \(n\) ，经过 \(T\) 步操作计算后，若证明</p>
    $$ \lim_{T \to \infty} L^\prime_j = 2 $$
    <p>成立，则第二类问题就得以证明不存在。</p>

  </section>
  <!-- =================================后记=================================================== -->
  <section>
    <h2>后记</h2>
    <p>这个问题我关注了好多年，作为一名业余爱好者一直在研究着。直到2019年底，<a class="ft"
        href="#ft3">陶哲轩证明了几乎所有数字都满足冰雹猜想</a>，再加上2020年初肺炎疫情，我有了个不得已的长假期，决定将自己的想法给写下来。也许此前已有数学家做过了相同的研究，要么是我没能找到对应的文献，要么是使用的数学语言超出了我所能理解的范围，但我未发现有完全重合的思路。此篇文章只是给出了一个模型，而我个人的数学能力不足以证明这个世界难题。希望本文能为有能力的学者带来一点帮助；如不嫌弃，请指出错漏之处。
    </p>
  </section>
  <hr />

  <!-- =================================脚注及参考文献=================================================== -->
  <section>
    <p class="ft" id="f1">① ② 为了方便阐述而特意添加的中间状态，事实上不需单独在计算过程中描述。</p>
    <p class="ft" id="f2">③ 本文对原冰雹问题做了调整，\((3 × 1 + 1) / 2 = 2\)，原问题的数字 \(4\) 在终结循环中跳过。</p>

    <h2>参考文献</h2>
    <p class="ft"><a class="lk" href="http://www.matrix67.com/blog/archives/6756">1. Matrix67 博客中的题目</a></p>
    <p class="ft" id="ft3">2. TERENCE TAO ( 陶哲轩 )，ALMOST ALL ORBITS OF THE COLLATZ MAP ATTAIN ALMOST BOUNDED VALUES</p>
    <p class="ft" id="ft3">3. 马成长 许松林 ，角谷猜想的动力学诠释，湖北工学院学报1996年第3期</p>
  </section>
</body>

</html>